package cn.ph0ebus.s2067.action;

import com.opensymphony.xwork2.ActionSupport;
import java.io.File;
import org.apache.commons.io.FileUtils;

public class UploadAction extends ActionSupport {
    private static final long serialVersionUID = 1L;
    private File upload;
    private String uploadContentType;
    private String uploadFileName;

    public UploadAction() {
    }

    public File getUpload() {
        return this.upload;
    }

    public void setUpload(File upload) {
        this.upload = upload;
    }

    public String getUploadContentType() {
        return this.uploadContentType;
    }

    public void setUploadContentType(String uploadContentType) {
        this.uploadContentType = uploadContentType;
    }

    public String getUploadFileName() {
        return this.uploadFileName;
    }

    public void setUploadFileName(String uploadFileName) {
        this.uploadFileName = uploadFileName;
    }

    public String doUpload() {
        String path = "/tmp";
        String realPath = path + File.separator + this.uploadFileName;

        try {
            FileUtils.copyFile(this.upload, new File(realPath));
        } catch (Exception e) {
            e.printStackTrace();
        }

        return "success";
    }
}

public HttpParameters appendAll(Map<String, Parameter> newParams) {
    this.remove(newParams.keySet());
    this.parameters.putAll(newParams);
    return this;
}

public HttpParameters remove(Set<String> paramsToRemove) {
    for(String paramName : paramsToRemove) {
        this.parameters.entrySet().removeIf((p) -> ((String)p.getKey()).equalsIgnoreCase(paramName));
    }

    return this;
}

private static String capitalizeBeanPropertyName(String propertyName) {
    if (propertyName.length() == 1) {
        return propertyName.toUpperCase();
    } else if (propertyName.startsWith("get") && propertyName.endsWith("()") && Character.isUpperCase(propertyName.substring(3, 4).charAt(0))) {
        return propertyName;
    } else if (propertyName.startsWith("set") && propertyName.endsWith(")") && Character.isUpperCase(propertyName.substring(3, 4).charAt(0))) {
        return propertyName;
    } else if (propertyName.startsWith("is") && propertyName.endsWith("()") && Character.isUpperCase(propertyName.substring(2, 3).charAt(0))) {
        return propertyName;
    } else {
        char first = propertyName.charAt(0);
        char second = propertyName.charAt(1);
        if (Character.isLowerCase(first) && Character.isUpperCase(second)) {
            return propertyName;
        } else {
            char[] chars = propertyName.toCharArray();
            chars[0] = Character.toUpperCase(chars[0]);
            return new String(chars);
        }
    }
}

public boolean equalsIgnoreCase(String anotherString) {
    return (this == anotherString) ? true
            : (anotherString != null)
            && (anotherString.value.length == value.length)
            && regionMatches(true, 0, anotherString, 0, value.length);
}

public boolean regionMatches(boolean ignoreCase, int toffset,
        String other, int ooffset, int len) {
    char ta[] = value;
    int to = toffset;
    char pa[] = other.value;
    int po = ooffset;
    // Note: toffset, ooffset, or len might be near -1>>>1.
    if ((ooffset < 0) || (toffset < 0)
            || (toffset > (long)value.length - len)
            || (ooffset > (long)other.value.length - len)) {
        return false;
    }
    while (len-- > 0) {
        char c1 = ta[to++];
        char c2 = pa[po++];
        if (c1 == c2) {
            continue;
        }
        if (ignoreCase) {
            // If characters don't match but case may be ignored,
            // try converting both characters to uppercase.
            // If the results match, then the comparison scan should
            // continue.
            char u1 = Character.toUpperCase(c1);
            char u2 = Character.toUpperCase(c2);
            if (u1 == u2) {
                continue;
            }
            // Unfortunately, conversion to uppercase does not work properly
            // for the Georgian alphabet, which has strange rules about case
            // conversion.  So we need to make one last check before
            // exiting.
            if (Character.toLowerCase(u1) == Character.toLowerCase(u2)) {
                continue;
            }
        }
        return false;
    }
    return true;
}

protected boolean acceptableName(String name) {
    if (this.isIgnoredDMI(name)) {
        LOG.trace("DMI is enabled, ignoring DMI method: {}", name);
        return false;
    } else {
        boolean accepted = this.isWithinLengthLimit(name) && !this.isExcluded(name) && this.isAccepted(name);
        if (this.devMode && accepted) {
            LOG.debug("Parameter [{}] was accepted and will be appended to action!", name);
        }

        return accepted;
    }
}

public class UploadsAction extends ActionSupport {
    private static final long serialVersionUID = 1L;
    private List<File> upload;
    private List<String> uploadContentType;
    private List<String> uploadFileName;

    //...
}

public Object getProperty(Map context, Object target, Object name) throws OgnlException {
    CompoundRoot root = (CompoundRoot)target;
    OgnlContext ognlContext = (OgnlContext)context;
    if (name instanceof Integer) {
        Integer index = (Integer)name;
        return root.cutStack(index);
    } else if (!(name instanceof String)) {
        return null;
    } else if ("top".equals(name)) {
        return root.size() > 0 ? root.get(0) : null;
    } else {
        for(Object o : root) {
            if (o != null) {
                try {
                    if (OgnlRuntime.hasGetProperty(ognlContext, o, name) || o instanceof Map && ((Map)o).containsKey(name)) {
                        return OgnlRuntime.getProperty(ognlContext, o, name);
                    }
                } catch (OgnlException e) {
                    if (e.getReason() != null) {
                        String msg = "Caught an Ognl exception while getting property " + name;
                        throw new StrutsException(msg, e);
                    }
                } catch (IntrospectionException var11) {
                }
            }
        }

        if (context.containsKey(OgnlValueStack.THROW_EXCEPTION_ON_FAILURE)) {
            throw new NoSuchPropertyException(target, name);
        } else {
            return null;
        }
    }
}

public String intercept(ActionInvocation invocation) throws Exception {
    HttpServletRequest request = invocation.getInvocationContext().getServletRequest();
    if (!(request instanceof MultiPartRequestWrapper)) {
        if (LOG.isDebugEnabled()) {
            ActionProxy proxy = invocation.getProxy();
            LOG.debug(this.getTextMessage("struts.messages.bypass.request", new String[]{proxy.getNamespace(), proxy.getActionName()}));
        }

        return invocation.invoke();
    } else {
        MultiPartRequestWrapper multiWrapper = (MultiPartRequestWrapper)request;
        if (!(invocation.getAction() instanceof UploadedFilesAware)) {
            LOG.debug("Action: {} doesn't implement: {}, ignoring file upload", invocation.getProxy().getActionName(), UploadedFilesAware.class.getSimpleName());
            return invocation.invoke();
        } else {
            UploadedFilesAware action = (UploadedFilesAware)invocation.getAction();
            this.applyValidation(action, multiWrapper);
            Enumeration<String> fileParameterNames = multiWrapper.getFileParameterNames();
            List<UploadedFile> acceptedFiles = new ArrayList();

            while(fileParameterNames != null && fileParameterNames.hasMoreElements()) {
                String inputName = (String)fileParameterNames.nextElement();
                UploadedFile[] uploadedFiles = multiWrapper.getFiles(inputName);
                if (uploadedFiles != null && uploadedFiles.length != 0) {
                    for(UploadedFile uploadedFile : uploadedFiles) {
                        if (this.acceptFile(action, uploadedFile, uploadedFile.getOriginalName(), uploadedFile.getContentType(), inputName)) {
                            acceptedFiles.add(uploadedFile);
                        }
                    }
                } else if (LOG.isWarnEnabled()) {
                    LOG.warn(this.getTextMessage(action, "struts.messages.invalid.file", new String[]{inputName}));
                }
            }

            if (acceptedFiles.isEmpty()) {
                LOG.debug("No files have been uploaded/accepted");
            } else {
                LOG.debug("Passing: {} uploaded file(s) to action", acceptedFiles.size());
                action.withUploadedFiles(acceptedFiles);
            }

            return invocation.invoke();
        }
    }
}